using System.Diagnostics;

namespace ConsoleApp12
{
    internal class Program
    {
        private const int iters = 10000000;

        static void Main(string[] args)
        {
            for (; ; )
            {
                for (int i = 0; i < 7; i++)
                {
                    int thrCount = 1 << i;
                    System.Console.WriteLine("Threads:" + thrCount);

                    for (int j = 0; j < 4; j++)
                    {
                        System.Console.Write("Fat Lock: ");
                        RunMany(() => FatLock(thrCount), thrCount);
                    }
                }

                System.Console.WriteLine();
            }
        }

        static void RunMany(Action f, int threadCount)
        {
            Thread[] threads = new Thread[threadCount];
            bool start = false;

            for (int i = 0; i < threads.Length; i++)
            {
                threads[i] = new Thread(
                    () =>
                    {
                        while (!start) Thread.SpinWait(1);
                        f();
                    }
                );

                threads[i].Start();
            }

            Thread.Sleep(10);
            start = true;

            Stopwatch sw = Stopwatch.StartNew();
            for (int i = 0; i < threads.Length; i++)
            {
                threads[i].Join();
            }

            System.Console.WriteLine("Ops per msec: " + iters / sw.ElapsedMilliseconds);
        }

        private static int Fib(int n) => n < 2 ? 1 : Fib(n - 1) + Fib(n - 2);
        private static int ComputeSomething(Random random)
        {
            int delay = random.Next(4, 10);
            return Fib(delay);
        }

        static System.Threading.Lock fatLock = new System.Threading.Lock();

        public static int sharedCounter = 0;
        public static Dictionary<int, int> sharedDictionary = new Dictionary<int, int>();

        static void FatLock(int thrCount)
        {
            Random random = new Random();
            for (int i = 0; i < iters / thrCount; i++)
            {
                // do some computation
                int value = ComputeSomething(random);
                var scope = fatLock.EnterScope();
                {
                    // update shared state
                    sharedCounter += value;
                    sharedDictionary[i] = sharedCounter;
                }
                scope.Dispose();
            }
        }
    }
}

. . . 
. . . 
        static System.Threading.Lock fatLock1 = new System.Threading.Lock();
        static System.Threading.Lock fatLock2 = new System.Threading.Lock();

        public static int sharedCounter1 = 0;
        public static int sharedCounter2 = 0;

        public static Dictionary<int, int> sharedDictionary1 = new Dictionary<int, int>();
        public static Dictionary<int, int> sharedDictionary2 = new Dictionary<int, int>();

        static void FatLock(int thrCount)
        {
            Random random = new Random();
            for (int i = 0; i < iters / thrCount; i++)
            {
                // do some computation
                int value = ComputeSomething(random);

                if (i % 2 == 0)
                {
                    var scope = fatLock1.EnterScope();
                    {
                        // update shared state
                        sharedCounter1 += value;
                        sharedDictionary1[i] = sharedCounter1;
                    }
                    scope.Dispose();

                }
                else
                {
                    var scope = fatLock2.EnterScope();
                    {
                        // update shared state
                        sharedCounter2 += value;
                        sharedDictionary2[i] = sharedCounter2;
                    }
                    scope.Dispose();
                }
            }
        }